// internal/planner/physical/generator.go
package physical

import (
	"NumberBase/internal/planner/logical"
	"NumberBase/internal/planner/types"
	"fmt"
)

// Generator 物理计划生成器
type Generator struct {
	// 可能需要配置和统计信息
}

// NewGenerator 创建物理计划生成器
func NewGenerator() *Generator {
	return &Generator{}
}

// Generate 从逻辑计划生成物理计划
func (g *Generator) Generate(plan types.LogicalPlan) (types.PhysicalPlan, error) {
	switch node := plan.(type) {
	case *logical.TableScan:
		return g.generateTableScan(node)
	case *logical.Filter:
		return g.generateFilter(node)
	case *logical.Projection:
		return g.generateProjection(node)
	// 其他节点类型...
	default:
		return nil, fmt.Errorf("不支持的逻辑计划节点: %T", node)
	}
}

// 生成物理表扫描
func (g *Generator) generateTableScan(node *logical.TableScan) (types.PhysicalPlan, error) {
	// 实际实现中，这里需要考虑可用索引和统计信息
	return &TableScan{
		TableName:     node.TableName,
		SchemaRef:     node.Schema(),
		EstimatedRows: 1000, // 简化，应通过统计信息估算
		costVal:       1000, // 简化的成本估算
	}, nil
}

// 生成物理过滤
func (g *Generator) generateFilter(node *logical.Filter) (types.PhysicalPlan, error) {
	childPlan, err := g.Generate(node.Children()[0])
	if err != nil {
		return nil, err
	}

	// 简化的成本估计：假设过滤掉一半数据
	inputCost := childPlan.Cost()
	filterCost := inputCost * 0.5

	return &Filter{
		Input:     childPlan,
		Condition: node.Condition,
		costVal:   inputCost + filterCost,
	}, nil
}

// 生成物理投影
func (g *Generator) generateProjection(node *logical.Projection) (types.PhysicalPlan, error) {
	childPlan, err := g.Generate(node.Children()[0])
	if err != nil {
		return nil, err
	}

	// 成本估计：投影的成本与输入行数成正比
	inputCost := childPlan.Cost()
	projCost := inputCost * 0.1 // 简化，投影操作相对轻量

	return &Projection{
		Input:        childPlan,
		Expressions:  node.Expressions,
		OutputSchema: node.Schema(),
		costVal:      inputCost + projCost,
	}, nil
}
